/*
@license

dhtmlxGantt v.6.3.7 Standard

This version of dhtmlxGantt is distributed under GPL 2.0 license and can be legally used in GPL projects.

To use dhtmlxGantt in non-GPL projects (and get Pro version of the product), please obtain Commercial/Enterprise or Ultimate license on our site https://dhtmlx.com/docs/products/dhtmlxGantt/#licensing or contact us at sales@dhtmlx.com

(c) XB Software Ltd.

*/
(function webpackUniversalModuleDefinition(root, factory) {
    if (typeof exports === 'object' && typeof module === 'object')
        module.exports = factory();
    else if (typeof define === 'function' && define.amd)
        define("ext/dhtmlxgantt_tooltip", [], factory);
    else if (typeof exports === 'object')
        exports["ext/dhtmlxgantt_tooltip"] = factory();
    else
        root["ext/dhtmlxgantt_tooltip"] = factory();
})(window, function () {
    return /******/ (function (modules) { // webpackBootstrap
        /******/ 	// The module cache
        /******/
        var installedModules = {};
        /******/
        /******/ 	// The require function
        /******/
        function __webpack_require__(moduleId) {
            /******/
            /******/ 		// Check if module is in cache
            /******/
            if (installedModules[moduleId]) {
                /******/
                return installedModules[moduleId].exports;
                /******/
            }
            /******/ 		// Create a new module (and put it into the cache)
            /******/
            var module = installedModules[moduleId] = {
                /******/            i: moduleId,
                /******/            l: false,
                /******/            exports: {}
                /******/
            };
            /******/
            /******/ 		// Execute the module function
            /******/
            modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
            /******/
            /******/ 		// Flag the module as loaded
            /******/
            module.l = true;
            /******/
            /******/ 		// Return the exports of the module
            /******/
            return module.exports;
            /******/
        }

        /******/
        /******/
        /******/ 	// expose the modules object (__webpack_modules__)
        /******/
        __webpack_require__.m = modules;
        /******/
        /******/ 	// expose the module cache
        /******/
        __webpack_require__.c = installedModules;
        /******/
        /******/ 	// define getter function for harmony exports
        /******/
        __webpack_require__.d = function (exports, name, getter) {
            /******/
            if (!__webpack_require__.o(exports, name)) {
                /******/
                Object.defineProperty(exports, name, {enumerable: true, get: getter});
                /******/
            }
            /******/
        };
        /******/
        /******/ 	// define __esModule on exports
        /******/
        __webpack_require__.r = function (exports) {
            /******/
            if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
                /******/
                Object.defineProperty(exports, Symbol.toStringTag, {value: 'Module'});
                /******/
            }
            /******/
            Object.defineProperty(exports, '__esModule', {value: true});
            /******/
        };
        /******/
        /******/ 	// create a fake namespace object
        /******/ 	// mode & 1: value is a module id, require it
        /******/ 	// mode & 2: merge all properties of value into the ns
        /******/ 	// mode & 4: return value when already ns object
        /******/ 	// mode & 8|1: behave like require
        /******/
        __webpack_require__.t = function (value, mode) {
            /******/
            if (mode & 1) value = __webpack_require__(value);
            /******/
            if (mode & 8) return value;
            /******/
            if ((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
            /******/
            var ns = Object.create(null);
            /******/
            __webpack_require__.r(ns);
            /******/
            Object.defineProperty(ns, 'default', {enumerable: true, value: value});
            /******/
            if (mode & 2 && typeof value != 'string') for (var key in value) __webpack_require__.d(ns, key, function (key) {
                return value[key];
            }.bind(null, key));
            /******/
            return ns;
            /******/
        };
        /******/
        /******/ 	// getDefaultExport function for compatibility with non-harmony modules
        /******/
        __webpack_require__.n = function (module) {
            /******/
            var getter = module && module.__esModule ?
                /******/            function getDefault() {
                    return module['default'];
                } :
                /******/            function getModuleExports() {
                    return module;
                };
            /******/
            __webpack_require__.d(getter, 'a', getter);
            /******/
            return getter;
            /******/
        };
        /******/
        /******/ 	// Object.prototype.hasOwnProperty.call
        /******/
        __webpack_require__.o = function (object, property) {
            return Object.prototype.hasOwnProperty.call(object, property);
        };
        /******/
        /******/ 	// __webpack_public_path__
        /******/
        __webpack_require__.p = "/codebase/sources/";
        /******/
        /******/
        /******/ 	// Load entry module and return exports
        /******/
        return __webpack_require__(__webpack_require__.s = "./sources/ext/tooltip/index.ts");
        /******/
    })
        /************************************************************************/
        /******/ ({

            /***/ "./sources/ext/tooltip/index.ts":
            /*!**************************************!*\
              !*** ./sources/ext/tooltip/index.ts ***!
              \**************************************/
            /*! no static exports found */
            /***/ (function (module, exports, __webpack_require__) {

                "use strict";

                Object.defineProperty(exports, "__esModule", {value: true});
                gantt.config.tooltip_timeout = 30;
                gantt.config.tooltip_offset_y = 20;
                gantt.config.tooltip_offset_x = 10;
                gantt.config.tooltip_hide_timeout = 30;
                var tooltipManager_1 = __webpack_require__(/*! ./tooltipManager */ "./sources/ext/tooltip/tooltipManager.ts");
                var tooltipManager = new tooltipManager_1.TooltipManager();
                gantt.ext.tooltips = tooltipManager;
                gantt.attachEvent("onGanttReady", function () {
                    tooltipManager.tooltipFor({
                        selector: "[" + gantt.config.task_attribute + "]:not(.gantt_task_row)",
                        html: function (event) {
                            if (gantt.config.touch && !gantt.config.touch_tooltip) {
                                return;
                            }
                            var targetTaskId = gantt.locate(event);
                            if (gantt.isTaskExists(targetTaskId)) {
                                var task = gantt.getTask(targetTaskId);
                                return gantt.templates.tooltip_text(task.start_date, task.end_date, task);
                            }
                            return null;
                        },
                        global: false
                    });
                });
                gantt.attachEvent("onDestroy", function () {
                    tooltipManager.destructor();
                });
                gantt.attachEvent("onLightbox", function () {
                    tooltipManager.hideTooltip();
                });
                var isLinkCreate = function () {
                    var state = gantt.getState();
                    return !!state.link_source_id;
                };
                gantt.attachEvent("onBeforeTooltip", function () {
                    if (isLinkCreate()) {
                        return false;
                    }
                });
                gantt.attachEvent("onGanttScroll", function () {
                    tooltipManager.hideTooltip();
                });


                /***/
            }),

            /***/ "./sources/ext/tooltip/tooltip.ts":
            /*!****************************************!*\
              !*** ./sources/ext/tooltip/tooltip.ts ***!
              \****************************************/
            /*! no static exports found */
            /***/ (function (module, exports, __webpack_require__) {

                "use strict";

                Object.defineProperty(exports, "__esModule", {value: true});
                var domHelpers = __webpack_require__(/*! ../../utils/dom_helpers */ "./sources/utils/dom_helpers.js");
                var Tooltip = /** @class */ (function () {
                    function Tooltip() {
                    }

                    Tooltip.prototype.getNode = function () {
                        if (!this._tooltipNode) {
                            this._tooltipNode = document.createElement("div");
                            this._tooltipNode.className = "gantt_tooltip";
                            gantt._waiAria.tooltipAttr(this._tooltipNode);
                        }
                        return this._tooltipNode;
                    };
                    Tooltip.prototype.setViewport = function (node) {
                        this._root = node;
                        return this;
                    };
                    Tooltip.prototype.show = function (left, top) {
                        var container = document.body;
                        var node = this.getNode();
                        if (!domHelpers.isChildOf(node, container)) {
                            this.hide();
                            container.appendChild(node);
                        }
                        if (this._isLikeMouseEvent(left)) {
                            var position = this._calculateTooltipPosition(left);
                            top = position.top;
                            left = position.left;
                        }
                        node.style.top = top + "px";
                        node.style.left = left + "px";
                        gantt._waiAria.tooltipVisibleAttr(node);
                        return this;
                    };
                    Tooltip.prototype.hide = function () {
                        var node = this.getNode();
                        if (node && node.parentNode) {
                            node.parentNode.removeChild(node);
                        }
                        gantt._waiAria.tooltipHiddenAttr(node);
                        return this;
                    };
                    Tooltip.prototype.setContent = function (html) {
                        var node = this.getNode();
                        node.innerHTML = html;
                        return this;
                    };
                    // it is for salesforce, because it proxies event to it own events
                    Tooltip.prototype._isLikeMouseEvent = function (event) {
                        if (!event || typeof event !== "object") {
                            return false;
                        }
                        return "clientX" in event && "clientY" in event;
                    };
                    Tooltip.prototype._getViewPort = function () {
                        return this._root || document.body;
                    };
                    Tooltip.prototype._calculateTooltipPosition = function (event) {
                        // top/left coordinates inside the viewport by mouse position
                        var viewport = this._getViewPortSize();
                        var tooltipNode = this.getNode();
                        var tooltip = {
                            top: 0,
                            left: 0,
                            width: tooltipNode.offsetWidth,
                            height: tooltipNode.offsetHeight,
                            bottom: 0,
                            right: 0
                        };
                        var offsetX = gantt.config.tooltip_offset_x;
                        var offsetY = gantt.config.tooltip_offset_y;
                        var container = document.body;
                        var mouse = domHelpers.getRelativeEventPosition(event, container);
                        var containerPos = domHelpers.getNodePosition(container);
                        mouse.y += containerPos.y; // to fix margin collapsing
                        tooltip.top = mouse.y;
                        tooltip.left = mouse.x;
                        tooltip.top += offsetY;
                        tooltip.left += offsetX;
                        tooltip.bottom = tooltip.top + tooltip.height;
                        tooltip.right = tooltip.left + tooltip.width;
                        var scrollTop = window.scrollY + container.scrollTop; // to fix margin collapsing
                        // edge cases when the tooltip element can be partially hidden by edges of the viewport
                        if (tooltip.top < viewport.top - scrollTop) {
                            tooltip.top = viewport.top;
                            tooltip.bottom = tooltip.top + tooltip.height;
                        } else if (tooltip.bottom > viewport.bottom) {
                            tooltip.bottom = viewport.bottom;
                            tooltip.top = tooltip.bottom - tooltip.height;
                        }
                        if (tooltip.left < viewport.left) {
                            tooltip.left = viewport.left;
                            tooltip.right = viewport.left + tooltip.width;
                        } else if (tooltip.right > viewport.right) {
                            tooltip.right = viewport.right;
                            tooltip.left = tooltip.right - tooltip.width;
                        }
                        if (mouse.x >= tooltip.left && mouse.x <= tooltip.right) {
                            tooltip.left = mouse.x - tooltip.width - offsetX;
                            tooltip.right = tooltip.left + tooltip.width;
                        }
                        if (mouse.y >= tooltip.top && mouse.y <= tooltip.bottom) {
                            tooltip.top = mouse.y - tooltip.height - offsetY;
                            tooltip.bottom = tooltip.top + tooltip.height;
                        }
                        return tooltip;
                    };
                    Tooltip.prototype._getViewPortSize = function () {
                        var container = this._getViewPort();
                        var viewport = container;
                        var scrollTop = window.scrollY + document.body.scrollTop;
                        var scrollLeft = window.scrollX + document.body.scrollLeft;
                        var pos;
                        // support for the initial tooltip mode where the tooltip element was attached to the data area of gantt
                        if (container === gantt.$task_data) {
                            viewport = gantt.$task;
                            scrollTop = 0;
                            scrollLeft = 0;
                            pos = domHelpers.getNodePosition(gantt.$task);
                        } else {
                            pos = domHelpers.getNodePosition(viewport);
                        }
                        return {
                            left: pos.x + scrollLeft,
                            top: pos.y + scrollTop,
                            width: pos.width,
                            height: pos.height,
                            bottom: pos.y + pos.height + scrollTop,
                            right: pos.x + pos.width + scrollLeft
                        };
                    };
                    return Tooltip;
                }());
                exports.Tooltip = Tooltip;


                /***/
            }),

            /***/ "./sources/ext/tooltip/tooltipManager.ts":
            /*!***********************************************!*\
              !*** ./sources/ext/tooltip/tooltipManager.ts ***!
              \***********************************************/
            /*! no static exports found */
            /***/ (function (module, exports, __webpack_require__) {

                "use strict";

                Object.defineProperty(exports, "__esModule", {value: true});
                var domEventsScope = __webpack_require__(/*! ../../utils/dom_event_scope */ "./sources/utils/dom_event_scope.js");
                var domHelpers = __webpack_require__(/*! ../../utils/dom_helpers */ "./sources/utils/dom_helpers.js");
                var helpers = __webpack_require__(/*! ../../utils/helpers */ "./sources/utils/helpers.js");
                var tooltip_1 = __webpack_require__(/*! ./tooltip */ "./sources/ext/tooltip/tooltip.ts");
                var TooltipManager = /** @class */ (function () {
                    function TooltipManager() {
                        this.tooltip = new tooltip_1.Tooltip();
                        this._listeners = {};
                        this._domEvents = domEventsScope();
                        this._initDelayedFunctions();
                    }

                    TooltipManager.prototype.destructor = function () {
                        this.tooltip.hide();
                        this._domEvents.detachAll();
                    };
                    TooltipManager.prototype.hideTooltip = function () {
                        this.delayHide();
                    };
                    TooltipManager.prototype.attach = function (config) {
                        var _this = this;
                        var root = document.body;
                        if (!config.global) {
                            root = gantt.$root;
                        }
                        var watchableTarget = null;
                        var handler = function (event) {
                            var eventTarget = domHelpers.getTargetNode(event);
                            var targetNode = domHelpers.closest(eventTarget, config.selector);
                            if (domHelpers.isChildOf(eventTarget, _this.tooltip.getNode())) {
                                return;
                            }
                            var doOnMouseEnter = function () {
                                watchableTarget = targetNode;
                                config.onmouseenter(event, targetNode);
                            };
                            if (watchableTarget) {
                                if (targetNode && targetNode === watchableTarget) {
                                    config.onmousemove(event, targetNode);
                                } else {
                                    config.onmouseleave(event, watchableTarget);
                                    watchableTarget = null;
                                    if (targetNode && targetNode !== watchableTarget) {
                                        doOnMouseEnter();
                                    }
                                }
                            } else {
                                if (targetNode) {
                                    doOnMouseEnter();
                                }
                            }
                        };
                        this.detach(config.selector);
                        this._domEvents.attach(root, "mousemove", handler);
                        this._listeners[config.selector] = {
                            node: root,
                            handler: handler
                        };
                    };
                    TooltipManager.prototype.detach = function (selector) {
                        var listener = this._listeners[selector];
                        if (listener) {
                            this._domEvents.detach(listener.node, "mousemove", listener.handler);
                        }
                    };
                    TooltipManager.prototype.tooltipFor = function (config) {
                        var _this = this;
                        var cloneDomEvent = function (event) {
                            var clone = event;
                            // making events survive timeout in ie
                            // tslint:disable-next-line no-string-literal
                            if (document["createEventObject"] && !document.createEvent) {
                                // tslint:disable-next-line no-string-literal
                                clone = document["createEventObject"](event);
                            }
                            return clone;
                        };
                        this._initDelayedFunctions();
                        this.attach({
                            selector: config.selector,
                            global: config.global,
                            onmouseenter: function (event, node) {
                                var html = config.html(event, node);
                                if (html) {
                                    _this.delayShow(cloneDomEvent(event), html);
                                }
                            },
                            onmousemove: function (event, node) {
                                var html = config.html(event, node);
                                if (html) {
                                    _this.delayShow(cloneDomEvent(event), html);
                                } else {
                                    _this.delayShow.$cancelTimeout();
                                    _this.delayHide();
                                }
                            },
                            onmouseleave: function () {
                                _this.delayShow.$cancelTimeout();
                                _this.delayHide();
                            },
                        });
                    };
                    TooltipManager.prototype._initDelayedFunctions = function () {
                        var _this = this;
                        // reset delayed functions in order to apply current values of tooltip_timeout
                        if (this.delayShow) {
                            this.delayShow.$cancelTimeout();
                        }
                        if (this.delayHide) {
                            this.delayHide.$cancelTimeout();
                        }
                        this.tooltip.hide();
                        this.delayShow = helpers.delay(function (event, html) {
                            if (gantt.callEvent("onBeforeTooltip", [event]) === false) {
                                _this.tooltip.hide();
                            } else {
                                _this.tooltip.setContent(html);
                                _this.tooltip.show(event);
                            }
                        }, gantt.config.tooltip_timeout || 1);
                        this.delayHide = helpers.delay(function () {
                            _this.delayShow.$cancelTimeout();
                            _this.tooltip.hide();
                        }, gantt.config.tooltip_hide_timeout || 1);
                    };
                    return TooltipManager;
                }());
                exports.TooltipManager = TooltipManager;


                /***/
            }),

            /***/ "./sources/utils/dom_event_scope.js":
            /*!******************************************!*\
              !*** ./sources/utils/dom_event_scope.js ***!
              \******************************************/
            /*! no static exports found */
            /***/ (function (module, exports, __webpack_require__) {

                var utils = __webpack_require__(/*! ./utils */ "./sources/utils/utils.js");

                function createScope(addEvent, removeEvent) {
                    addEvent = addEvent || utils.event;
                    removeEvent = removeEvent || utils.eventRemove;

                    var handlers = [];

                    var eventScope = {
                        attach: function (el, event, callback, capture) {
                            handlers.push({element: el, event: event, callback: callback, capture: capture});
                            addEvent(el, event, callback, capture);
                        },
                        detach: function (el, event, callback, capture) {
                            removeEvent(el, event, callback, capture);
                            for (var i = 0; i < handlers.length; i++) {
                                var handler = handlers[i];
                                if (handler.element === el && handler.event === event && handler.callback === callback && handler.capture === capture) {
                                    handlers.splice(i, 1);
                                    i--;
                                }
                            }
                        },
                        detachAll: function () {
                            var staticArray = handlers.slice();
                            // original handlers array can be spliced on every iteration
                            for (var i = 0; i < staticArray.length; i++) {
                                var handler = staticArray[i];
                                eventScope.detach(handler.element, handler.event, handler.callback, handler.capture);
                                eventScope.detach(handler.element, handler.event, handler.callback, undefined);
                                eventScope.detach(handler.element, handler.event, handler.callback, false);
                                eventScope.detach(handler.element, handler.event, handler.callback, true);
                            }
                            handlers.splice(0, handlers.length);
                        },
                        extend: function () {
                            return createScope(this.event, this.eventRemove);
                        }
                    };

                    if (!window.scopes) {
                        window.scopes = [];
                    }
                    window.scopes.push(handlers);
                    return eventScope;
                }

                module.exports = createScope;

                /***/
            }),

            /***/ "./sources/utils/dom_helpers.js":
            /*!**************************************!*\
              !*** ./sources/utils/dom_helpers.js ***!
              \**************************************/
            /*! no static exports found */
            /***/ (function (module, exports) {

//returns position of html element on the page
                function elementPosition(elem) {
                    var top = 0, left = 0, right = 0, bottom = 0;
                    if (elem.getBoundingClientRect) { //HTML5 method
                        var box = elem.getBoundingClientRect();
                        var body = document.body;
                        var docElem = (document.documentElement ||
                            document.body.parentNode ||
                            document.body);

                        var scrollTop = window.pageYOffset || docElem.scrollTop || body.scrollTop;
                        var scrollLeft = window.pageXOffset || docElem.scrollLeft || body.scrollLeft;
                        var clientTop = docElem.clientTop || body.clientTop || 0;
                        var clientLeft = docElem.clientLeft || body.clientLeft || 0;
                        top = box.top + scrollTop - clientTop;
                        left = box.left + scrollLeft - clientLeft;

                        right = document.body.offsetWidth - box.right;
                        bottom = document.body.offsetHeight - box.bottom;
                    } else { //fallback to naive approach
                        while (elem) {
                            top = top + parseInt(elem.offsetTop, 10);
                            left = left + parseInt(elem.offsetLeft, 10);
                            elem = elem.offsetParent;
                        }

                        right = document.body.offsetWidth - elem.offsetWidth - left;
                        bottom = document.body.offsetHeight - elem.offsetHeight - top;
                    }
                    return {
                        y: Math.round(top),
                        x: Math.round(left),
                        width: elem.offsetWidth,
                        height: elem.offsetHeight,
                        right: Math.round(right),
                        bottom: Math.round(bottom)
                    };
                }

                function isVisible(node) {
                    var display = false,
                        visibility = false;
                    if (window.getComputedStyle) {
                        var style = window.getComputedStyle(node, null);
                        display = style["display"];
                        visibility = style["visibility"];
                    } else if (node.currentStyle) {
                        display = node.currentStyle["display"];
                        visibility = node.currentStyle["visibility"];
                    }
                    return (display != "none" && visibility != "hidden");
                }

                function hasNonNegativeTabIndex(node) {
                    return !isNaN(node.getAttribute("tabindex")) && (node.getAttribute("tabindex") * 1 >= 0);
                }

                function hasHref(node) {
                    var canHaveHref = {"a": true, "area": true};
                    if (canHaveHref[node.nodeName.loLowerCase()]) {
                        return !!node.getAttribute("href");
                    }
                    return true;
                }

                function isEnabled(node) {
                    var canDisable = {"input": true, "select": true, "textarea": true, "button": true, "object": true};
                    if (canDisable[node.nodeName.toLowerCase()]) {
                        return !node.hasAttribute("disabled");
                    }

                    return true;
                }

                function getFocusableNodes(root) {
                    var nodes = root.querySelectorAll([
                        "a[href]",
                        "area[href]",
                        "input",
                        "select",
                        "textarea",
                        "button",
                        "iframe",
                        "object",
                        "embed",
                        "[tabindex]",
                        "[contenteditable]"
                    ].join(", "));

                    var nodesArray = Array.prototype.slice.call(nodes, 0);
                    for (var i = 0; i < nodesArray.length; i++) {
                        var node = nodesArray[i];
                        var isValid = (hasNonNegativeTabIndex(node) || isEnabled(node) || hasHref(node)) && isVisible(node);
                        if (!isValid) {
                            nodesArray.splice(i, 1);
                            i--;
                        }
                    }
                    return nodesArray;
                }

                function getScrollSize() {
                    var div = document.createElement("div");
                    div.style.cssText = "visibility:hidden;position:absolute;left:-1000px;width:100px;padding:0px;margin:0px;height:110px;min-height:100px;overflow-y:scroll;";

                    document.body.appendChild(div);
                    var width = div.offsetWidth - div.clientWidth;
                    document.body.removeChild(div);

                    return width;
                }

                function getClassName(node) {
                    if (!node) return "";

                    var className = node.className || "";
                    if (className.baseVal)//'className' exist but not a string - IE svg element in DOM
                        className = className.baseVal;

                    if (!className.indexOf)
                        className = "";

                    return _trimString(className);
                }

                function addClassName(node, className) {
                    if (className && node.className.indexOf(className) === -1) {
                        node.className += " " + className;
                    }
                }

                function removeClassName(node, name) {
                    name = name.split(" ");
                    for (var i = 0; i < name.length; i++) {
                        var regEx = new RegExp("\\s?\\b" + name[i] + "\\b(?![-_.])", "");
                        node.className = node.className.replace(regEx, "");
                    }
                }

                function hasClass(element, className) {
                    if ('classList' in element) {
                        return element.classList.contains(className);
                    } else {
                        return new RegExp("\\b" + className + "\\b").test(element.className);
                    }
                }

                function toNode(node) {
                    if (typeof node === "string") {
                        return (document.getElementById(node) || document.querySelector(node) || document.body);
                    }
                    return node || document.body;
                }

                var _slave = document.createElement("div");

                function insert(node, newone) {
                    _slave.innerHTML = newone;
                    var child = _slave.firstChild;
                    node.appendChild(child);
                    return child;
                }

                function remove(node) {
                    if (node && node.parentNode) {
                        node.parentNode.removeChild(node);
                    }
                }

                function getChildren(node, css) {
                    var ch = node.childNodes;
                    var len = ch.length;
                    var out = [];
                    for (var i = 0; i < len; i++) {
                        var obj = ch[i];
                        if (obj.className && obj.className.indexOf(css) !== -1) {
                            out.push(obj);
                        }
                    }
                    return out;
                }

                function getTargetNode(e) {
                    var trg;
                    if (e.tagName)
                        trg = e;
                    else {
                        e = e || window.event;
                        trg = e.target || e.srcElement;
                    }
                    return trg;
                }

                function locateAttribute(e, attribute) {
                    if (!attribute) return;

                    var trg = getTargetNode(e);

                    while (trg) {
                        if (trg.getAttribute) {	//text nodes has not getAttribute
                            var test = trg.getAttribute(attribute);
                            if (test) return trg;
                        }
                        trg = trg.parentNode;
                    }
                    return null;
                }

                function _trimString(str) {
                    var func = String.prototype.trim || function () {
                        return this.replace(/^\s+|\s+$/g, "");
                    };
                    return func.apply(str);
                }

                function locateClassName(e, classname, strict) {
                    var trg = getTargetNode(e);
                    var css = "";

                    if (strict === undefined)
                        strict = true;

                    while (trg) {
                        css = getClassName(trg);
                        if (css) {
                            var ind = css.indexOf(classname);
                            if (ind >= 0) {
                                if (!strict)
                                    return trg;

                                //check that we have exact match
                                var left = (ind === 0) || (!_trimString(css.charAt(ind - 1)));
                                var right = ((ind + classname.length >= css.length)) || (!_trimString(css.charAt(ind + classname.length)));

                                if (left && right)
                                    return trg;
                            }
                        }
                        trg = trg.parentNode;
                    }
                    return null;
                }

                /*
                event position relatively to DOM element
                 */
                function getRelativeEventPosition(ev, node) {
                    var d = document.documentElement;
                    var box = elementPosition(node);

                    return {
                        x: ev.clientX + d.scrollLeft - d.clientLeft - box.x + node.scrollLeft,
                        y: ev.clientY + d.scrollTop - d.clientTop - box.y + node.scrollTop
                    };
                }

                function isChildOf(child, parent) {
                    if (!child || !parent) {
                        return false;
                    }

                    while (child && child != parent) {
                        child = child.parentNode;
                    }

                    return child === parent;
                }

                function closest(element, selector) {
                    if (element.closest) {
                        return element.closest(selector);
                    } else if (element.matches || element.msMatchesSelector || element.webkitMatchesSelector) {
                        var el = element;
                        if (!document.documentElement.contains(el)) return null;
                        do {
                            var method = el.matches || el.msMatchesSelector || el.webkitMatchesSelector;

                            if (method.call(el, selector)) return el;
                            el = el.parentElement || el.parentNode;
                        } while (el !== null && el.nodeType === 1);
                        return null;
                    } else {
                        // eslint-disable-next-line no-console
                        console.error("Your browser is not supported");
                        return null;
                    }
                }

                module.exports = {
                    getNodePosition: elementPosition,
                    getFocusableNodes: getFocusableNodes,
                    getScrollSize: getScrollSize,
                    getClassName: getClassName,
                    addClassName: addClassName,
                    removeClassName: removeClassName,
                    insertNode: insert,
                    removeNode: remove,
                    getChildNodes: getChildren,
                    toNode: toNode,
                    locateClassName: locateClassName,
                    locateAttribute: locateAttribute,
                    getTargetNode: getTargetNode,
                    getRelativeEventPosition: getRelativeEventPosition,
                    isChildOf: isChildOf,
                    hasClass: hasClass,
                    closest: closest
                };

                /***/
            }),

            /***/ "./sources/utils/helpers.js":
            /*!**********************************!*\
              !*** ./sources/utils/helpers.js ***!
              \**********************************/
            /*! no static exports found */
            /***/ (function (module, exports) {

                var units = {
                    "second": 1,
                    "minute": 60,
                    "hour": 60 * 60,
                    "day": 60 * 60 * 24,
                    "week": 60 * 60 * 24 * 7,
                    "month": 60 * 60 * 24 * 30,
                    "quarter": 60 * 60 * 24 * 30 * 3,
                    "year": 60 * 60 * 24 * 365
                };

                function getSecondsInUnit(unit) {
                    return units[unit] || units.hour;
                }

                function forEach(arr, callback) {
                    if (arr.forEach) {
                        arr.forEach(callback);
                    } else {
                        var workArray = arr.slice();
                        for (var i = 0; i < workArray.length; i++) {
                            callback(workArray[i], i);
                        }
                    }
                }

                function arrayMap(arr, callback) {
                    if (arr.map) {
                        return arr.map(callback);
                    } else {
                        var workArray = arr.slice();
                        var resArray = [];

                        for (var i = 0; i < workArray.length; i++) {
                            resArray.push(callback(workArray[i], i));
                        }
                        return resArray;
                    }
                }


                function arrayFind(arr, callback) {
                    if (arr.find) {
                        return arr.find(callback);
                    } else {
                        for (var i = 0; i < arr.length; i++) {
                            if (callback(arr[i], i)) {
                                return arr[i];
                            }
                        }
                    }
                }

// iframe-safe array type check instead of using instanceof
                function isArray(obj) {
                    if (Array.isArray) {
                        return Array.isArray(obj);
                    } else {
                        // close enough
                        return (obj && obj.length !== undefined && obj.pop && obj.push);
                    }
                }

// non-primitive string object, e.g. new String("abc")
                function isStringObject(obj) {
                    return obj && typeof obj === "object"
                        && Function.prototype.toString.call(obj.constructor) === "function String() { [native code] }";
                }

// non-primitive number object, e.g. new Number(5)
                function isNumberObject(obj) {
                    return obj && typeof obj === "object"
                        && Function.prototype.toString.call(obj.constructor) === "function Number() { [native code] }";
                }

// non-primitive number object, e.g. new Boolean(true)
                function isBooleanObject(obj) {
                    return obj && typeof obj === "object"
                        && Function.prototype.toString.call(obj.constructor) === "function Boolean() { [native code] }";
                }

                function isDate(obj) {
                    if (obj && typeof obj === "object") {
                        return !!(obj.getFullYear && obj.getMonth && obj.getDate);
                    } else {
                        return false;
                    }
                }

                function isValidDate(obj) {
                    return isDate(obj) && !isNaN(obj.getTime());
                }

                function arrayFilter(arr, callback) {
                    var result = [];

                    if (arr.filter) {
                        return arr.filter(callback);
                    } else {
                        for (var i = 0; i < arr.length; i++) {
                            if (callback(arr[i], i)) {
                                result[result.length] = arr[i];
                            }
                        }
                        return result;
                    }
                }

                function hashToArray(hash) {
                    var result = [];

                    for (var key in hash) {
                        if (hash.hasOwnProperty(key)) {
                            result.push(hash[key]);
                        }
                    }

                    return result;
                }

                function arraySome(arr, callback) {
                    if (arr.length === 0) return false;

                    for (var i = 0; i < arr.length; i++) {
                        if (callback(arr[i], i, arr)) {
                            return true;
                        }
                    }
                    return false;
                }

                function arrayDifference(arr, callback) {
                    return arrayFilter(arr, function (item, i) {
                        return !callback(item, i);
                    });
                }

                function throttle(callback, timeout) {
                    var wait = false;

                    return function () {
                        if (!wait) {
                            callback.apply(null, arguments);
                            wait = true;
                            setTimeout(function () {
                                wait = false;
                            }, timeout);
                        }
                    };
                }

                function delay(callback, timeout) {
                    var timer;

                    var result = function () {
                        result.$cancelTimeout();
                        callback.$pending = true;
                        var args = Array.prototype.slice.call(arguments);
                        timer = setTimeout(function () {
                            callback.apply(this, args);
                            result.$pending = false;
                        }, timeout);
                    };

                    result.$pending = false;
                    result.$cancelTimeout = function () {
                        clearTimeout(timer);
                        callback.$pending = false;
                    };
                    result.$execute = function () {
                        callback();
                        callback.$cancelTimeout();
                    };

                    return result;
                }

                function sortArrayOfHash(arr, field, desc) {
                    var compare = function (a, b) {
                        return a < b;
                    };

                    arr.sort(function (a, b) {
                        if (a[field] === b[field]) return 0;

                        return desc ? compare(a[field], b[field]) : compare(b[field], a[field]);
                    });
                }

                function objectKeys(obj) {
                    if (Object.keys) {
                        return Object.keys(obj);
                    }
                    var result = [];
                    var key;
                    for (key in obj) {
                        if (Object.prototype.hasOwnProperty.call(obj, key)) {
                            result.push(key);
                        }
                    }
                    return result;
                }

                function requestAnimationFrame(callback) {
                    var w = window;
                    var foundRequestAnimationFrame = w.requestAnimationFrame
                        || w.webkitRequestAnimationFrame
                        || w.msRequestAnimationFrame
                        || w.mozRequestAnimationFrame
                        || w.oRequestAnimationFrame
                        || function (cb) {
                            setTimeout(cb, 1000 / 60);
                        };
                    return foundRequestAnimationFrame(callback);
                }

                function isEventable(obj) {
                    return obj.attachEvent && obj.detachEvent;
                }

                module.exports = {
                    getSecondsInUnit: getSecondsInUnit,
                    forEach: forEach,
                    arrayMap: arrayMap,
                    arrayFind: arrayFind,
                    arrayFilter: arrayFilter,
                    arrayDifference: arrayDifference,
                    arraySome: arraySome,
                    hashToArray: hashToArray,
                    sortArrayOfHash: sortArrayOfHash,
                    throttle: throttle,
                    isArray: isArray,
                    isDate: isDate,
                    isValidDate: isValidDate,
                    isStringObject: isStringObject,
                    isNumberObject: isNumberObject,
                    isBooleanObject: isBooleanObject,
                    delay: delay,
                    objectKeys: objectKeys,
                    requestAnimationFrame: requestAnimationFrame,
                    isEventable: isEventable
                };

                /***/
            }),

            /***/ "./sources/utils/utils.js":
            /*!********************************!*\
              !*** ./sources/utils/utils.js ***!
              \********************************/
            /*! no static exports found */
            /***/ (function (module, exports, __webpack_require__) {

                var helpers = __webpack_require__(/*! ./helpers */ "./sources/utils/helpers.js");

                function isCustomType(object) {
                    var constructorString = object.constructor.toString();
                    var plainObjectConstructor = ({}).constructor.toString();

                    return constructorString !== plainObjectConstructor;
                }

                function copy(object) {
                    var i, result; // iterator, types array, result

                    if (object && typeof object == "object") {

                        switch (true) {
                            case (helpers.isDate(object)):
                                result = new Date(object);
                                break;
                            case (helpers.isArray(object)):
                                result = new Array(object.length);
                                for (i = 0; i < object.length; i++) {
                                    result[i] = copy(object[i]);
                                }
                                break;
                            case (helpers.isStringObject(object)):
                                result = new String(object);
                                break;
                            case (helpers.isNumberObject(object)):
                                result = new Number(object);
                                break;
                            case (helpers.isBooleanObject(object)):
                                result = new Boolean(object);
                                break;
                            default:
                                if (isCustomType(object)) {
                                    result = Object.create(object);
                                } else {
                                    result = {};
                                }

                                for (i in object) {
                                    if (Object.prototype.hasOwnProperty.apply(object, [i]))
                                        result[i] = copy(object[i]);
                                }
                                break;
                        }
                    }
                    return result || object;
                }

                function mixin(target, source, force) {
                    for (var f in source)
                        if (((target[f] === undefined) || force)) target[f] = source[f];
                    return target;
                }

                function defined(obj) {
                    return typeof (obj) != "undefined";
                }

                var seed;

                function uid() {
                    if (!seed)
                        seed = (new Date()).valueOf();

                    seed++;
                    return seed;
                }

//creates function with specified "this" pointer
                function bind(functor, object) {
                    if (functor.bind)
                        return functor.bind(object);
                    else
                        return function () {
                            return functor.apply(object, arguments);
                        };
                }

                function event(el, event, handler, capture) {
                    if (el.addEventListener)
                        el.addEventListener(event, handler, capture === undefined ? false : capture);

                    else if (el.attachEvent)
                        el.attachEvent("on" + event, handler);
                }

                function eventRemove(el, event, handler, capture) {
                    if (el.removeEventListener)
                        el.removeEventListener(event, handler, capture === undefined ? false : capture);

                    else if (el.detachEvent)
                        el.detachEvent("on" + event, handler);
                }

                module.exports = {
                    copy: copy,
                    defined: defined,
                    mixin: mixin,
                    uid: uid,
                    bind: bind,
                    event: event,
                    eventRemove: eventRemove
                };

                /***/
            })

            /******/
        });
});
